{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#作图%lsmagic\n",
    "\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "#import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 金价\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 35.15) (1, 31.615055089233497)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# rmb：yxb\n",
    "rmb_yxb_rate=[1,37]\n",
    "#点券- rxb -\n",
    "db_yxb_rate=[3195,1000]\n",
    "\n",
    "qb_rate=0.95\n",
    "db_rate=0.99\n",
    "# 归一化, 不提现直接充值\n",
    "def func(rmb_yxb_rate,db_yxb_rate):\n",
    "  \n",
    "    rmb_yxb_rate=(1/qb_rate,rmb_yxb_rate[1])\n",
    "    rmb_yxb_rate=(1,rmb_yxb_rate[1]/rmb_yxb_rate[0])\n",
    "    db_yxb_rate[1]=db_yxb_rate[1]/db_rate\n",
    "    db_yxb_rate=(1,db_yxb_rate[1]/db_yxb_rate[0]*100)\n",
    "    print(rmb_yxb_rate,db_yxb_rate)\n",
    "    x = np.linspace(0, 1999,1999)\n",
    "    yrmb=x*rmb_yxb_rate[1]\n",
    "    ydb=x*db_yxb_rate[1]\n",
    "    \n",
    "    plt.plot(x, yrmb)\n",
    "    plt.plot(x, ydb)\n",
    "    plt.grid()  # 生成网格\n",
    "    plt.show()\n",
    "\n",
    "func(rmb_yxb_rate,db_yxb_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1.0/(1+np.e**(-x))\n",
    "x = np.linspace(-2, 2,66)\n",
    "y = sigmoid(-4*x+3)/sigmoid(3)\n",
    "plt.plot(x, y)\n",
    "plt.grid()  # 生成网格\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7478.7"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "charge=0.03\n",
    "charge=1-charge\n",
    "item_price=7710\n",
    "\n",
    "item_price*charge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 寄售"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0.0\n",
      "2 0.0\n",
      "3 0.0\n",
      "4 0.0\n",
      "5 0.0\n",
      "6 0.0\n",
      "7 321.14285714285717\n",
      "8 0.0\n",
      "9 326.6666666666667\n",
      "10 0.0\n",
      "20 322.0\n"
     ]
    }
   ],
   "source": [
    "wrate={1:0,2:0,3:0,4:0,\n",
    "       5:0,\n",
    "       6:0,7:2248,\n",
    "       8:0,\n",
    "       9:2940,\n",
    "       10:0,\n",
    "       20:6440}\n",
    "for k,v in wrate.items():\n",
    "    print(k,v/k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 抽奖"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# 深渊\n",
    "import random\n",
    "\n",
    "超星空=0.1\n",
    "星空=0.05\n",
    "次数=100\n",
    "cnt =0\n",
    "for i in range(int(次数/2)):\n",
    "    if random.uniform(0,1)<超星空:\n",
    "        cnt +=1\n",
    "print(\"超星空出货\",cnt)\n",
    "cnt =0\n",
    "for i in range(次数):\n",
    "     if random.uniform(0,1)<星空:\n",
    "        cnt +=1\n",
    "print(\"星空出货\",cnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2365088204232788"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.uniform(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module random:\n",
      "\n",
      "NAME\n",
      "    random - Random variable generators.\n",
      "\n",
      "DESCRIPTION\n",
      "        integers\n",
      "        --------\n",
      "               uniform within range\n",
      "    \n",
      "        sequences\n",
      "        ---------\n",
      "               pick random element\n",
      "               pick random sample\n",
      "               pick weighted random sample\n",
      "               generate random permutation\n",
      "    \n",
      "        distributions on the real line:\n",
      "        ------------------------------\n",
      "               uniform\n",
      "               triangular\n",
      "               normal (Gaussian)\n",
      "               lognormal\n",
      "               negative exponential\n",
      "               gamma\n",
      "               beta\n",
      "               pareto\n",
      "               Weibull\n",
      "    \n",
      "        distributions on the circle (angles 0 to 2pi)\n",
      "        ---------------------------------------------\n",
      "               circular uniform\n",
      "               von Mises\n",
      "    \n",
      "    General notes on the underlying Mersenne Twister core generator:\n",
      "    \n",
      "    * The period is 2**19937-1.\n",
      "    * It is one of the most extensively tested generators in existence.\n",
      "    * The random() method is implemented in C, executes in a single Python step,\n",
      "      and is, therefore, threadsafe.\n",
      "\n",
      "CLASSES\n",
      "    _random.Random(builtins.object)\n",
      "        Random\n",
      "            SystemRandom\n",
      "    \n",
      "    class Random(_random.Random)\n",
      "     |  Random number generator base class used by bound module functions.\n",
      "     |  \n",
      "     |  Used to instantiate instances of Random to get generators that don't\n",
      "     |  share state.\n",
      "     |  \n",
      "     |  Class Random can also be subclassed if you want to use a different basic\n",
      "     |  generator of your own devising: in that case, override the following\n",
      "     |  methods:  random(), seed(), getstate(), and setstate().\n",
      "     |  Optionally, implement a getrandbits() method so that randrange()\n",
      "     |  can cover arbitrarily large ranges.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  getstate(self)\n",
      "     |      Return internal state; can be passed to setstate() later.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  seed(self, a=None, version=2)\n",
      "     |      Initialize internal state from hashable object.\n",
      "     |      \n",
      "     |      None or no argument seeds from current time or from an operating\n",
      "     |      system specific randomness source if available.\n",
      "     |      \n",
      "     |      If *a* is an int, all bits are used.\n",
      "     |      \n",
      "     |      For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "     |      bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "     |      sequences from older versions of Python), the algorithm for str and\n",
      "     |      bytes generates a narrower range of seeds.\n",
      "     |  \n",
      "     |  setstate(self, state)\n",
      "     |      Restore internal state from object returned by getstate().\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  getrandbits(...)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  random(...)\n",
      "     |      random() -> x in the interval [0, 1).\n",
      "    \n",
      "    class SystemRandom(Random)\n",
      "     |  Alternate random number generator using sources provided\n",
      "     |  by the operating system (such as /dev/urandom on Unix or\n",
      "     |  CryptGenRandom on Windows).\n",
      "     |  \n",
      "     |   Not available on all systems (see os.urandom() for details).\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SystemRandom\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  getrandbits(self, k)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  getstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  random(self)\n",
      "     |      Get the next random number in the range [0.0, 1.0).\n",
      "     |  \n",
      "     |  seed(self, *args, **kwds)\n",
      "     |      Stub method.  Not used for a system random number generator.\n",
      "     |  \n",
      "     |  setstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from Random:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from Random:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from Random:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    betavariate(alpha, beta) method of Random instance\n",
      "        Beta distribution.\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        Returned values range between 0 and 1.\n",
      "    \n",
      "    choice(seq) method of Random instance\n",
      "        Choose a random element from a non-empty sequence.\n",
      "    \n",
      "    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance\n",
      "        Return a k sized list of population elements chosen with replacement.\n",
      "        \n",
      "        If the relative weights or cumulative weights are not specified,\n",
      "        the selections are made with equal probability.\n",
      "    \n",
      "    expovariate(lambd) method of Random instance\n",
      "        Exponential distribution.\n",
      "        \n",
      "        lambd is 1.0 divided by the desired mean.  It should be\n",
      "        nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "        a reserved word in Python.)  Returned values range from 0 to\n",
      "        positive infinity if lambd is positive, and from negative\n",
      "        infinity to 0 if lambd is negative.\n",
      "    \n",
      "    gammavariate(alpha, beta) method of Random instance\n",
      "        Gamma distribution.  Not the gamma function!\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        \n",
      "        The probability distribution function is:\n",
      "        \n",
      "                    x ** (alpha - 1) * math.exp(-x / beta)\n",
      "          pdf(x) =  --------------------------------------\n",
      "                      math.gamma(alpha) * beta ** alpha\n",
      "    \n",
      "    gauss(mu, sigma) method of Random instance\n",
      "        Gaussian distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.  This is\n",
      "        slightly faster than the normalvariate() function.\n",
      "        \n",
      "        Not thread-safe without a lock around calls.\n",
      "    \n",
      "    getrandbits(...) method of Random instance\n",
      "        getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "    \n",
      "    getstate() method of Random instance\n",
      "        Return internal state; can be passed to setstate() later.\n",
      "    \n",
      "    lognormvariate(mu, sigma) method of Random instance\n",
      "        Log normal distribution.\n",
      "        \n",
      "        If you take the natural logarithm of this distribution, you'll get a\n",
      "        normal distribution with mean mu and standard deviation sigma.\n",
      "        mu can have any value, and sigma must be greater than zero.\n",
      "    \n",
      "    normalvariate(mu, sigma) method of Random instance\n",
      "        Normal distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.\n",
      "    \n",
      "    paretovariate(alpha) method of Random instance\n",
      "        Pareto distribution.  alpha is the shape parameter.\n",
      "    \n",
      "    randint(a, b) method of Random instance\n",
      "        Return random integer in range [a, b], including both end points.\n",
      "    \n",
      "    random(...) method of Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    randrange(start, stop=None, step=1, _int=<class 'int'>) method of Random instance\n",
      "        Choose a random item from range(start, stop[, step]).\n",
      "        \n",
      "        This fixes the problem with randint() which includes the\n",
      "        endpoint; in Python this is usually not what you want.\n",
      "    \n",
      "    sample(population, k) method of Random instance\n",
      "        Chooses k unique random elements from a population sequence or set.\n",
      "        \n",
      "        Returns a new list containing elements from the population while\n",
      "        leaving the original population unchanged.  The resulting list is\n",
      "        in selection order so that all sub-slices will also be valid random\n",
      "        samples.  This allows raffle winners (the sample) to be partitioned\n",
      "        into grand prize and second place winners (the subslices).\n",
      "        \n",
      "        Members of the population need not be hashable or unique.  If the\n",
      "        population contains repeats, then each occurrence is a possible\n",
      "        selection in the sample.\n",
      "        \n",
      "        To choose a sample in a range of integers, use range as an argument.\n",
      "        This is especially fast and space efficient for sampling from a\n",
      "        large population:   sample(range(10000000), 60)\n",
      "    \n",
      "    seed(a=None, version=2) method of Random instance\n",
      "        Initialize internal state from hashable object.\n",
      "        \n",
      "        None or no argument seeds from current time or from an operating\n",
      "        system specific randomness source if available.\n",
      "        \n",
      "        If *a* is an int, all bits are used.\n",
      "        \n",
      "        For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "        bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "        sequences from older versions of Python), the algorithm for str and\n",
      "        bytes generates a narrower range of seeds.\n",
      "    \n",
      "    setstate(state) method of Random instance\n",
      "        Restore internal state from object returned by getstate().\n",
      "    \n",
      "    shuffle(x, random=None) method of Random instance\n",
      "        Shuffle list x in place, and return None.\n",
      "        \n",
      "        Optional argument random is a 0-argument function returning a\n",
      "        random float in [0.0, 1.0); if it is the default None, the\n",
      "        standard random.random will be used.\n",
      "    \n",
      "    triangular(low=0.0, high=1.0, mode=None) method of Random instance\n",
      "        Triangular distribution.\n",
      "        \n",
      "        Continuous distribution bounded by given lower and upper limits,\n",
      "        and having a given mode value in-between.\n",
      "        \n",
      "        http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "    \n",
      "    uniform(a, b) method of Random instance\n",
      "        Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "    \n",
      "    vonmisesvariate(mu, kappa) method of Random instance\n",
      "        Circular data distribution.\n",
      "        \n",
      "        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "        kappa is the concentration parameter, which must be greater than or\n",
      "        equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "        to a uniform random angle over the range 0 to 2*pi.\n",
      "    \n",
      "    weibullvariate(alpha, beta) method of Random instance\n",
      "        Weibull distribution.\n",
      "        \n",
      "        alpha is the scale parameter and beta is the shape parameter.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['Random', 'seed', 'random', 'uniform', 'randint', 'choice',...\n",
      "\n",
      "FILE\n",
      "    c:\\program files\\python36\\lib\\random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
